﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using GPSTrackingDBV2.Entities;
using GPSTrackingDBV2.Data;
using GPSTrackingDBV2.Data.Bases;

#endregion

namespace GPSTrackingDBV2.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <see cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("GPSTrackingDBV2.Data") as NetTiersServiceSection;
				}

				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
					return WebConfigurationManager.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region StockByAditionalImagesLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockByAditionalImagesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockByAditionalImagesLogProviderBase StockByAditionalImagesLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockByAditionalImagesLogProvider;
			}
		}
		
		#endregion
		
		#region AdministratorsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Administrators"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdministratorsProviderBase AdministratorsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdministratorsProvider;
			}
		}
		
		#endregion
		
		#region StockCategoriesByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockCategoriesByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockCategoriesByCompaniesProviderBase StockCategoriesByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockCategoriesByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region StockCategoriesLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockCategoriesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockCategoriesLogProviderBase StockCategoriesLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockCategoriesLogProvider;
			}
		}
		
		#endregion
		
		#region StockCategoriesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockCategories"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockCategoriesProviderBase StockCategoriesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockCategoriesProvider;
			}
		}
		
		#endregion
		
		#region StockByAditionalImagesLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockByAditionalImagesLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockByAditionalImagesLogByUuidProviderBase StockByAditionalImagesLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockByAditionalImagesLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region StockFilesTypeOfFileProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesTypeOfFile"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesTypeOfFileProviderBase StockFilesTypeOfFileProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesTypeOfFileProvider;
			}
		}
		
		#endregion
		
		#region StockCategoriesLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockCategoriesLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockCategoriesLogByUuidProviderBase StockCategoriesLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockCategoriesLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region StockFilesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFiles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesProviderBase StockFilesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesProvider;
			}
		}
		
		#endregion
		
		#region StockFilesLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesLogProviderBase StockFilesLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesLogProvider;
			}
		}
		
		#endregion
		
		#region StockFilesByUsernameLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesByUsernameLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesByUsernameLogProviderBase StockFilesByUsernameLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesByUsernameLogProvider;
			}
		}
		
		#endregion
		
		#region StockFilesLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesLogByUuidProviderBase StockFilesLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region StockFilesByUsernameLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesByUsernameLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesByUsernameLogByUuidProviderBase StockFilesByUsernameLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesByUsernameLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region StockFilesByUsernameProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesByUsername"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesByUsernameProviderBase StockFilesByUsernameProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesByUsernameProvider;
			}
		}
		
		#endregion
		
		#region StockProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Stock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockProviderBase StockProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockProvider;
			}
		}
		
		#endregion
		
		#region NumCardControlByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NumCardControlByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NumCardControlByCompaniesProviderBase NumCardControlByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NumCardControlByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region StatusProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Status"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StatusProviderBase StatusProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StatusProvider;
			}
		}
		
		#endregion
		
		#region OrderProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Order"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrderProviderBase OrderProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrderProvider;
			}
		}
		
		#endregion
		
		#region NotificationTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationTypeProviderBase NotificationTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationTypeProvider;
			}
		}
		
		#endregion
		
		#region NotificationsControlDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationsControlDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsControlDetailsProviderBase NotificationsControlDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsControlDetailsProvider;
			}
		}
		
		#endregion
		
		#region NotificationsTrackDataProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationsTrackData"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsTrackDataProviderBase NotificationsTrackDataProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsTrackDataProvider;
			}
		}
		
		#endregion
		
		#region OrderDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="OrderDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static OrderDetailProviderBase OrderDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.OrderDetailProvider;
			}
		}
		
		#endregion
		
		#region NotificationsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Notifications"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsProviderBase NotificationsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsProvider;
			}
		}
		
		#endregion
		
		#region SettingProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Setting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SettingProviderBase SettingProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SettingProvider;
			}
		}
		
		#endregion
		
		#region RoutesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Routes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RoutesProviderBase RoutesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RoutesProvider;
			}
		}
		
		#endregion
		
		#region SequenceByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SequenceByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SequenceByCompaniesProviderBase SequenceByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SequenceByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region StockByAditionalImagesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockByAditionalImages"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockByAditionalImagesProviderBase StockByAditionalImagesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockByAditionalImagesProvider;
			}
		}
		
		#endregion
		
		#region ScheduleWorkProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ScheduleWork"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ScheduleWorkProviderBase ScheduleWorkProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ScheduleWorkProvider;
			}
		}
		
		#endregion
		
		#region SequenceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Sequence"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SequenceProviderBase SequenceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SequenceProvider;
			}
		}
		
		#endregion
		
		#region StockFilesTypeOfFileLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesTypeOfFileLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesTypeOfFileLogProviderBase StockFilesTypeOfFileLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesTypeOfFileLogProvider;
			}
		}
		
		#endregion
		
		#region ScheduleWorkByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ScheduleWorkByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ScheduleWorkByCompaniesProviderBase ScheduleWorkByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ScheduleWorkByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region UsersLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersLogProviderBase UsersLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersLogProvider;
			}
		}
		
		#endregion
		
		#region UsersGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersGroupsProviderBase UsersGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersGroupsProvider;
			}
		}
		
		#endregion
		
		#region UsersGroupsByDepartmentsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersGroupsByDepartments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersGroupsByDepartmentsProviderBase UsersGroupsByDepartmentsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersGroupsByDepartmentsProvider;
			}
		}
		
		#endregion
		
		#region CompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Companies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesProviderBase CompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesProvider;
			}
		}
		
		#endregion
		
		#region UsersLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersLogByUuidProviderBase UsersLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region UsersProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Users"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersProviderBase UsersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersProvider;
			}
		}
		
		#endregion
		
		#region UsersByUsersGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersByUsersGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersByUsersGroupsProviderBase UsersByUsersGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersByUsersGroupsProvider;
			}
		}
		
		#endregion
		
		#region StockFilesTypeOfFileLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockFilesTypeOfFileLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockFilesTypeOfFileLogByUuidProviderBase StockFilesTypeOfFileLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockFilesTypeOfFileLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region VpcControlProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VpcControl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VpcControlProviderBase VpcControlProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VpcControlProvider;
			}
		}
		
		#endregion
		
		#region UsersByGpsStocksProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersByGpsStocks"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersByGpsStocksProviderBase UsersByGpsStocksProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersByGpsStocksProvider;
			}
		}
		
		#endregion
		
		#region VpcTrackDataProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VpcTrackData"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VpcTrackDataProviderBase VpcTrackDataProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VpcTrackDataProvider;
			}
		}
		
		#endregion
		
		#region VpcRecordTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VpcRecordType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VpcRecordTypeProviderBase VpcRecordTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VpcRecordTypeProvider;
			}
		}
		
		#endregion
		
		#region VpcRecordLsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VpcRecordLs"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VpcRecordLsProviderBase VpcRecordLsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VpcRecordLsProvider;
			}
		}
		
		#endregion
		
		#region VpcProcessProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VpcProcess"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VpcProcessProviderBase VpcProcessProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VpcProcessProvider;
			}
		}
		
		#endregion
		
		#region VpcProcessDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VpcProcessDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VpcProcessDetailsProviderBase VpcProcessDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VpcProcessDetailsProvider;
			}
		}
		
		#endregion
		
		#region WindowsServicesLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="WindowsServicesLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static WindowsServicesLogProviderBase WindowsServicesLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.WindowsServicesLogProvider;
			}
		}
		
		#endregion
		
		#region UsersByGpsGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersByGpsGroupsProviderBase UsersByGpsGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersByGpsGroupsProvider;
			}
		}
		
		#endregion
		
		#region UsersByEmailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UsersByEmail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UsersByEmailProviderBase UsersByEmailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UsersByEmailProvider;
			}
		}
		
		#endregion
		
		#region TrackDataProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TrackData"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TrackDataProviderBase TrackDataProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TrackDataProvider;
			}
		}
		
		#endregion
		
		#region StockSettingProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockSetting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockSettingProviderBase StockSettingProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockSettingProvider;
			}
		}
		
		#endregion
		
		#region StockLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockLogProviderBase StockLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockLogProvider;
			}
		}
		
		#endregion
		
		#region StockLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockLogByUuidProviderBase StockLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region TrackDataByClientsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TrackDataByClients"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TrackDataByClientsProviderBase TrackDataByClientsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TrackDataByClientsProvider;
			}
		}
		
		#endregion
		
		#region StockSettingValuesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StockSettingValues"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StockSettingValuesProviderBase StockSettingValuesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StockSettingValuesProvider;
			}
		}
		
		#endregion
		
		#region TrackDataLastLocationProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TrackDataLastLocation"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TrackDataLastLocationProviderBase TrackDataLastLocationProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TrackDataLastLocationProvider;
			}
		}
		
		#endregion
		
		#region UserRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UserRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UserRolesProviderBase UserRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UserRolesProvider;
			}
		}
		
		#endregion
		
		#region UserRolesByUsersProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UserRolesByUsers"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UserRolesByUsersProviderBase UserRolesByUsersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UserRolesByUsersProvider;
			}
		}
		
		#endregion
		
		#region TypeModulesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TypeModules"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TypeModulesProviderBase TypeModulesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TypeModulesProvider;
			}
		}
		
		#endregion
		
		#region TrackDataLastVpcProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TrackDataLastVpc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TrackDataLastVpcProviderBase TrackDataLastVpcProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TrackDataLastVpcProvider;
			}
		}
		
		#endregion
		
		#region TrackDataLastLocationNotificationsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TrackDataLastLocationNotifications"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TrackDataLastLocationNotificationsProviderBase TrackDataLastLocationNotificationsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TrackDataLastLocationNotificationsProvider;
			}
		}
		
		#endregion
		
		#region NotificationsControlProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationsControl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsControlProviderBase NotificationsControlProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsControlProvider;
			}
		}
		
		#endregion
		
		#region NotificationsByGpsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationsByGps"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsByGpsProviderBase NotificationsByGpsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsByGpsProvider;
			}
		}
		
		#endregion
		
		#region ClientsLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsLogProviderBase ClientsLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsLogProvider;
			}
		}
		
		#endregion
		
		#region ClientsGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsGroupsProviderBase ClientsGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsGroupsProvider;
			}
		}
		
		#endregion
		
		#region ClientsControlProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsControl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsControlProviderBase ClientsControlProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsControlProvider;
			}
		}
		
		#endregion
		
		#region ClientsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Clients"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsProviderBase ClientsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsProvider;
			}
		}
		
		#endregion
		
		#region ClientsLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsLogByUuidProviderBase ClientsLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region ClientsGroupsByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsGroupsByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsGroupsByCompaniesProviderBase ClientsGroupsByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsGroupsByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region ClientsToVisitProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsToVisit"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsToVisitProviderBase ClientsToVisitProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsToVisitProvider;
			}
		}
		
		#endregion
		
		#region CompaniesByAdministratorsRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CompaniesByAdministratorsRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesByAdministratorsRolesProviderBase CompaniesByAdministratorsRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesByAdministratorsRolesProvider;
			}
		}
		
		#endregion
		
		#region CompaniesByMenuProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CompaniesByMenu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesByMenuProviderBase CompaniesByMenuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesByMenuProvider;
			}
		}
		
		#endregion
		
		#region CompaniesByMastersProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CompaniesByMasters"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesByMastersProviderBase CompaniesByMastersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesByMastersProvider;
			}
		}
		
		#endregion
		
		#region CompaniesByGpsGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CompaniesByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesByGpsGroupsProviderBase CompaniesByGpsGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesByGpsGroupsProvider;
			}
		}
		
		#endregion
		
		#region CompaniesByGeoFencesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CompaniesByGeoFences"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesByGeoFencesProviderBase CompaniesByGeoFencesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesByGeoFencesProvider;
			}
		}
		
		#endregion
		
		#region CompaniesByDepartmentsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CompaniesByDepartments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesByDepartmentsProviderBase CompaniesByDepartmentsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesByDepartmentsProvider;
			}
		}
		
		#endregion
		
		#region ClientsByEmailLogByUuidProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsByEmailLogByUuid"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsByEmailLogByUuidProviderBase ClientsByEmailLogByUuidProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsByEmailLogByUuidProvider;
			}
		}
		
		#endregion
		
		#region ClientsByEmailLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsByEmailLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsByEmailLogProviderBase ClientsByEmailLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsByEmailLogProvider;
			}
		}
		
		#endregion
		
		#region ClientsByEmailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsByEmail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsByEmailProviderBase ClientsByEmailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsByEmailProvider;
			}
		}
		
		#endregion
		
		#region AdministratorsRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdministratorsRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdministratorsRolesProviderBase AdministratorsRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdministratorsRolesProvider;
			}
		}
		
		#endregion
		
		#region AdministratorsRolesByAdministratorProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdministratorsRolesByAdministrator"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdministratorsRolesByAdministratorProviderBase AdministratorsRolesByAdministratorProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdministratorsRolesByAdministratorProvider;
			}
		}
		
		#endregion
		
		#region AdministratorsByEmailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdministratorsByEmail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdministratorsByEmailProviderBase AdministratorsByEmailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdministratorsByEmailProvider;
			}
		}
		
		#endregion
		
		#region AdministratorsByDepartmentsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdministratorsByDepartments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdministratorsByDepartmentsProviderBase AdministratorsByDepartmentsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdministratorsByDepartmentsProvider;
			}
		}
		
		#endregion
		
		#region BusRoutesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BusRoutes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BusRoutesProviderBase BusRoutesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BusRoutesProvider;
			}
		}
		
		#endregion
		
		#region BusRoutesDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BusRoutesDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BusRoutesDetailsProviderBase BusRoutesDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BusRoutesDetailsProvider;
			}
		}
		
		#endregion
		
		#region ClientsByClientsGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ClientsByClientsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ClientsByClientsGroupsProviderBase ClientsByClientsGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ClientsByClientsGroupsProvider;
			}
		}
		
		#endregion
		
		#region CatalogStatisticsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CatalogStatistics"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CatalogStatisticsProviderBase CatalogStatisticsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CatalogStatisticsProvider;
			}
		}
		
		#endregion
		
		#region BusStopProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BusStop"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BusStopProviderBase BusStopProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BusStopProvider;
			}
		}
		
		#endregion
		
		#region BusRouteByGpsGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BusRouteByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BusRouteByGpsGroupsProviderBase BusRouteByGpsGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BusRouteByGpsGroupsProvider;
			}
		}
		
		#endregion
		
		#region BusStopByBusRoutesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BusStopByBusRoutes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BusStopByBusRoutesProviderBase BusStopByBusRoutesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BusStopByBusRoutesProvider;
			}
		}
		
		#endregion
		
		#region CompaniesBySettingProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CompaniesBySetting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CompaniesBySettingProviderBase CompaniesBySettingProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CompaniesBySettingProvider;
			}
		}
		
		#endregion
		
		#region BusRouteByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BusRouteByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BusRouteByCompaniesProviderBase BusRouteByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BusRouteByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region MastersRolesByMasterProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MastersRolesByMaster"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MastersRolesByMasterProviderBase MastersRolesByMasterProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MastersRolesByMasterProvider;
			}
		}
		
		#endregion
		
		#region MenuTypesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MenuTypes"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MenuTypesProviderBase MenuTypesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MenuTypesProvider;
			}
		}
		
		#endregion
		
		#region MastersProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Masters"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MastersProviderBase MastersProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MastersProvider;
			}
		}
		
		#endregion
		
		#region DayNamesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DayNames"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DayNamesProviderBase DayNamesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DayNamesProvider;
			}
		}
		
		#endregion
		
		#region MasterRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MasterRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MasterRolesProviderBase MasterRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MasterRolesProvider;
			}
		}
		
		#endregion
		
		#region MenuProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Menu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MenuProviderBase MenuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MenuProvider;
			}
		}
		
		#endregion
		
		#region LogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Log"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static LogProviderBase LogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.LogProvider;
			}
		}
		
		#endregion
		
		#region GpsTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GpsType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GpsTypeProviderBase GpsTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GpsTypeProvider;
			}
		}
		
		#endregion
		
		#region MenuByAdministratorRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MenuByAdministratorRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MenuByAdministratorRolesProviderBase MenuByAdministratorRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MenuByAdministratorRolesProvider;
			}
		}
		
		#endregion
		
		#region NotificationsByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationsByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationsByCompaniesProviderBase NotificationsByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationsByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region MessageQueueLogProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MessageQueueLog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MessageQueueLogProviderBase MessageQueueLogProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MessageQueueLogProvider;
			}
		}
		
		#endregion
		
		#region MenuByUserRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MenuByUserRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MenuByUserRolesProviderBase MenuByUserRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MenuByUserRolesProvider;
			}
		}
		
		#endregion
		
		#region MenuByMasterRolesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MenuByMasterRoles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MenuByMasterRolesProviderBase MenuByMasterRolesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MenuByMasterRolesProvider;
			}
		}
		
		#endregion
		
		#region GpsModelsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GpsModels"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GpsModelsProviderBase GpsModelsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GpsModelsProvider;
			}
		}
		
		#endregion
		
		#region GpsStockProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GpsStock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GpsStockProviderBase GpsStockProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GpsStockProvider;
			}
		}
		
		#endregion
		
		#region GpsStockByGpsGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GpsStockByGpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GpsStockByGpsGroupsProviderBase GpsStockByGpsGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GpsStockByGpsGroupsProvider;
			}
		}
		
		#endregion
		
		#region EmailToSendStocksProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="EmailToSendStocks"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static EmailToSendStocksProviderBase EmailToSendStocksProvider
		{
			get 
			{
				LoadProviders();
				return _provider.EmailToSendStocksProvider;
			}
		}
		
		#endregion
		
		#region EmailToSendStockByClientsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="EmailToSendStockByClients"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static EmailToSendStockByClientsProviderBase EmailToSendStockByClientsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.EmailToSendStockByClientsProvider;
			}
		}
		
		#endregion
		
		#region DriversProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Drivers"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DriversProviderBase DriversProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DriversProvider;
			}
		}
		
		#endregion
		
		#region DepartmentsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Departments"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DepartmentsProviderBase DepartmentsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DepartmentsProvider;
			}
		}
		
		#endregion
		
		#region DriversByCompaniesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DriversByCompanies"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DriversByCompaniesProviderBase DriversByCompaniesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DriversByCompaniesProvider;
			}
		}
		
		#endregion
		
		#region EmailToSendStockByStockFilesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="EmailToSendStockByStockFiles"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static EmailToSendStockByStockFilesProviderBase EmailToSendStockByStockFilesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.EmailToSendStockByStockFilesProvider;
			}
		}
		
		#endregion
		
		#region NotificationByGeoFencesByGpsStockProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NotificationByGeoFencesByGpsStock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NotificationByGeoFencesByGpsStockProviderBase NotificationByGeoFencesByGpsStockProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NotificationByGeoFencesByGpsStockProvider;
			}
		}
		
		#endregion
		
		#region GeoFencesProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GeoFences"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GeoFencesProviderBase GeoFencesProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GeoFencesProvider;
			}
		}
		
		#endregion
		
		#region EmailToSendStockByStocksProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="EmailToSendStockByStocks"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static EmailToSendStockByStocksProviderBase EmailToSendStockByStocksProvider
		{
			get 
			{
				LoadProviders();
				return _provider.EmailToSendStockByStocksProvider;
			}
		}
		
		#endregion
		
		#region GpsCommandsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GpsCommands"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GpsCommandsProviderBase GpsCommandsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GpsCommandsProvider;
			}
		}
		
		#endregion
		
		#region GpsGroupsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GpsGroups"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GpsGroupsProviderBase GpsGroupsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GpsGroupsProvider;
			}
		}
		
		#endregion
		
		#region GeoFencesByGpsStockProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GeoFencesByGpsStock"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GeoFencesByGpsStockProviderBase GeoFencesByGpsStockProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GeoFencesByGpsStockProvider;
			}
		}
		
		#endregion
		
		#region GeoFenceDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GeoFenceDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GeoFenceDetailsProviderBase GeoFenceDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GeoFenceDetailsProvider;
			}
		}
		
		#endregion
		
		#region WorkTimeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="WorkTime"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static WorkTimeProviderBase WorkTimeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.WorkTimeProvider;
			}
		}
		
		#endregion
		
		
		#endregion
	}
	
	#region Query/Filters
		
	#region StockByAditionalImagesLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockByAditionalImagesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockByAditionalImagesLogFilters : StockByAditionalImagesLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogFilters class.
		/// </summary>
		public StockByAditionalImagesLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockByAditionalImagesLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockByAditionalImagesLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockByAditionalImagesLogFilters
	
	#region StockByAditionalImagesLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockByAditionalImagesLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockByAditionalImagesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockByAditionalImagesLogQuery : StockByAditionalImagesLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogQuery class.
		/// </summary>
		public StockByAditionalImagesLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockByAditionalImagesLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockByAditionalImagesLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockByAditionalImagesLogQuery
		
	#region AdministratorsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Administrators"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsFilters : AdministratorsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsFilters class.
		/// </summary>
		public AdministratorsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsFilters
	
	#region AdministratorsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdministratorsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Administrators"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsQuery : AdministratorsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsQuery class.
		/// </summary>
		public AdministratorsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsQuery
		
	#region StockCategoriesByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockCategoriesByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesByCompaniesFilters : StockCategoriesByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesByCompaniesFilters class.
		/// </summary>
		public StockCategoriesByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesByCompaniesFilters
	
	#region StockCategoriesByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockCategoriesByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockCategoriesByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesByCompaniesQuery : StockCategoriesByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesByCompaniesQuery class.
		/// </summary>
		public StockCategoriesByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesByCompaniesQuery
		
	#region StockCategoriesLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockCategoriesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesLogFilters : StockCategoriesLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogFilters class.
		/// </summary>
		public StockCategoriesLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesLogFilters
	
	#region StockCategoriesLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockCategoriesLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockCategoriesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesLogQuery : StockCategoriesLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogQuery class.
		/// </summary>
		public StockCategoriesLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesLogQuery
		
	#region StockCategoriesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockCategories"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesFilters : StockCategoriesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesFilters class.
		/// </summary>
		public StockCategoriesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesFilters
	
	#region StockCategoriesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockCategoriesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockCategories"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesQuery : StockCategoriesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesQuery class.
		/// </summary>
		public StockCategoriesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesQuery
		
	#region StockByAditionalImagesLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockByAditionalImagesLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockByAditionalImagesLogByUuidFilters : StockByAditionalImagesLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogByUuidFilters class.
		/// </summary>
		public StockByAditionalImagesLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockByAditionalImagesLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockByAditionalImagesLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockByAditionalImagesLogByUuidFilters
	
	#region StockByAditionalImagesLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockByAditionalImagesLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockByAditionalImagesLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockByAditionalImagesLogByUuidQuery : StockByAditionalImagesLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogByUuidQuery class.
		/// </summary>
		public StockByAditionalImagesLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockByAditionalImagesLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockByAditionalImagesLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockByAditionalImagesLogByUuidQuery
		
	#region StockFilesTypeOfFileFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesTypeOfFile"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesTypeOfFileFilters : StockFilesTypeOfFileFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileFilters class.
		/// </summary>
		public StockFilesTypeOfFileFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesTypeOfFileFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesTypeOfFileFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesTypeOfFileFilters
	
	#region StockFilesTypeOfFileQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesTypeOfFileParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesTypeOfFile"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesTypeOfFileQuery : StockFilesTypeOfFileParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileQuery class.
		/// </summary>
		public StockFilesTypeOfFileQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesTypeOfFileQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesTypeOfFileQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesTypeOfFileQuery
		
	#region StockCategoriesLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockCategoriesLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesLogByUuidFilters : StockCategoriesLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogByUuidFilters class.
		/// </summary>
		public StockCategoriesLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesLogByUuidFilters
	
	#region StockCategoriesLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockCategoriesLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockCategoriesLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockCategoriesLogByUuidQuery : StockCategoriesLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogByUuidQuery class.
		/// </summary>
		public StockCategoriesLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockCategoriesLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockCategoriesLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockCategoriesLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockCategoriesLogByUuidQuery
		
	#region StockFilesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFiles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesFilters : StockFilesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesFilters class.
		/// </summary>
		public StockFilesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesFilters
	
	#region StockFilesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFiles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesQuery : StockFilesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesQuery class.
		/// </summary>
		public StockFilesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesQuery
		
	#region StockFilesLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesLogFilters : StockFilesLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesLogFilters class.
		/// </summary>
		public StockFilesLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesLogFilters
	
	#region StockFilesLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesLogQuery : StockFilesLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesLogQuery class.
		/// </summary>
		public StockFilesLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesLogQuery
		
	#region StockFilesByUsernameLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesByUsernameLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesByUsernameLogFilters : StockFilesByUsernameLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogFilters class.
		/// </summary>
		public StockFilesByUsernameLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesByUsernameLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesByUsernameLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesByUsernameLogFilters
	
	#region StockFilesByUsernameLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesByUsernameLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesByUsernameLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesByUsernameLogQuery : StockFilesByUsernameLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogQuery class.
		/// </summary>
		public StockFilesByUsernameLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesByUsernameLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesByUsernameLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesByUsernameLogQuery
		
	#region StockFilesLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesLogByUuidFilters : StockFilesLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesLogByUuidFilters class.
		/// </summary>
		public StockFilesLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesLogByUuidFilters
	
	#region StockFilesLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesLogByUuidQuery : StockFilesLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesLogByUuidQuery class.
		/// </summary>
		public StockFilesLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesLogByUuidQuery
		
	#region StockFilesByUsernameLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesByUsernameLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesByUsernameLogByUuidFilters : StockFilesByUsernameLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogByUuidFilters class.
		/// </summary>
		public StockFilesByUsernameLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesByUsernameLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesByUsernameLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesByUsernameLogByUuidFilters
	
	#region StockFilesByUsernameLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesByUsernameLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesByUsernameLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesByUsernameLogByUuidQuery : StockFilesByUsernameLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogByUuidQuery class.
		/// </summary>
		public StockFilesByUsernameLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesByUsernameLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesByUsernameLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesByUsernameLogByUuidQuery
		
	#region StockFilesByUsernameFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesByUsername"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesByUsernameFilters : StockFilesByUsernameFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameFilters class.
		/// </summary>
		public StockFilesByUsernameFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesByUsernameFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesByUsernameFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesByUsernameFilters
	
	#region StockFilesByUsernameQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesByUsernameParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesByUsername"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesByUsernameQuery : StockFilesByUsernameParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameQuery class.
		/// </summary>
		public StockFilesByUsernameQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesByUsernameQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesByUsernameQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesByUsernameQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesByUsernameQuery
		
	#region StockFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Stock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilters : StockFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilters class.
		/// </summary>
		public StockFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilters
	
	#region StockQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Stock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockQuery : StockParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockQuery class.
		/// </summary>
		public StockQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockQuery
		
	#region NumCardControlByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NumCardControlByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NumCardControlByCompaniesFilters : NumCardControlByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NumCardControlByCompaniesFilters class.
		/// </summary>
		public NumCardControlByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NumCardControlByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NumCardControlByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NumCardControlByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NumCardControlByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NumCardControlByCompaniesFilters
	
	#region NumCardControlByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NumCardControlByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NumCardControlByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NumCardControlByCompaniesQuery : NumCardControlByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NumCardControlByCompaniesQuery class.
		/// </summary>
		public NumCardControlByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NumCardControlByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NumCardControlByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NumCardControlByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NumCardControlByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NumCardControlByCompaniesQuery
		
	#region StatusFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Status"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StatusFilters : StatusFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StatusFilters class.
		/// </summary>
		public StatusFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StatusFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StatusFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StatusFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StatusFilters
	
	#region StatusQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StatusParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Status"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StatusQuery : StatusParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StatusQuery class.
		/// </summary>
		public StatusQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StatusQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StatusQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StatusQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StatusQuery
		
	#region OrderFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Order"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrderFilters : OrderFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrderFilters class.
		/// </summary>
		public OrderFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrderFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrderFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrderFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrderFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrderFilters
	
	#region OrderQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrderParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Order"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrderQuery : OrderParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrderQuery class.
		/// </summary>
		public OrderQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrderQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrderQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrderQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrderQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrderQuery
		
	#region NotificationTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationTypeFilters : NotificationTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationTypeFilters class.
		/// </summary>
		public NotificationTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationTypeFilters
	
	#region NotificationTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationTypeQuery : NotificationTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationTypeQuery class.
		/// </summary>
		public NotificationTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationTypeQuery
		
	#region NotificationsControlDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationsControlDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsControlDetailsFilters : NotificationsControlDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsControlDetailsFilters class.
		/// </summary>
		public NotificationsControlDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsControlDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsControlDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsControlDetailsFilters
	
	#region NotificationsControlDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsControlDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationsControlDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsControlDetailsQuery : NotificationsControlDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsControlDetailsQuery class.
		/// </summary>
		public NotificationsControlDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsControlDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsControlDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsControlDetailsQuery
		
	#region NotificationsTrackDataFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationsTrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsTrackDataFilters : NotificationsTrackDataFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsTrackDataFilters class.
		/// </summary>
		public NotificationsTrackDataFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsTrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsTrackDataFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsTrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsTrackDataFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsTrackDataFilters
	
	#region NotificationsTrackDataQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsTrackDataParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationsTrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsTrackDataQuery : NotificationsTrackDataParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsTrackDataQuery class.
		/// </summary>
		public NotificationsTrackDataQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsTrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsTrackDataQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsTrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsTrackDataQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsTrackDataQuery
		
	#region OrderDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="OrderDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrderDetailFilters : OrderDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrderDetailFilters class.
		/// </summary>
		public OrderDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrderDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrderDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrderDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrderDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrderDetailFilters
	
	#region OrderDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="OrderDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="OrderDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class OrderDetailQuery : OrderDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the OrderDetailQuery class.
		/// </summary>
		public OrderDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the OrderDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public OrderDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the OrderDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public OrderDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion OrderDetailQuery
		
	#region NotificationsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Notifications"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsFilters : NotificationsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsFilters class.
		/// </summary>
		public NotificationsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsFilters
	
	#region NotificationsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Notifications"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsQuery : NotificationsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsQuery class.
		/// </summary>
		public NotificationsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsQuery
		
	#region SettingFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Setting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SettingFilters : SettingFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SettingFilters class.
		/// </summary>
		public SettingFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SettingFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SettingFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SettingFilters
	
	#region SettingQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SettingParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Setting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SettingQuery : SettingParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SettingQuery class.
		/// </summary>
		public SettingQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SettingQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SettingQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SettingQuery
		
	#region RoutesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Routes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RoutesFilters : RoutesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RoutesFilters class.
		/// </summary>
		public RoutesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RoutesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RoutesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RoutesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RoutesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RoutesFilters
	
	#region RoutesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RoutesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Routes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RoutesQuery : RoutesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RoutesQuery class.
		/// </summary>
		public RoutesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RoutesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RoutesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RoutesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RoutesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RoutesQuery
		
	#region SequenceByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SequenceByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SequenceByCompaniesFilters : SequenceByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SequenceByCompaniesFilters class.
		/// </summary>
		public SequenceByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SequenceByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SequenceByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SequenceByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SequenceByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SequenceByCompaniesFilters
	
	#region SequenceByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SequenceByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SequenceByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SequenceByCompaniesQuery : SequenceByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SequenceByCompaniesQuery class.
		/// </summary>
		public SequenceByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SequenceByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SequenceByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SequenceByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SequenceByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SequenceByCompaniesQuery
		
	#region StockByAditionalImagesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockByAditionalImages"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockByAditionalImagesFilters : StockByAditionalImagesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesFilters class.
		/// </summary>
		public StockByAditionalImagesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockByAditionalImagesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockByAditionalImagesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockByAditionalImagesFilters
	
	#region StockByAditionalImagesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockByAditionalImagesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockByAditionalImages"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockByAditionalImagesQuery : StockByAditionalImagesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesQuery class.
		/// </summary>
		public StockByAditionalImagesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockByAditionalImagesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockByAditionalImagesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockByAditionalImagesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockByAditionalImagesQuery
		
	#region ScheduleWorkFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ScheduleWork"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ScheduleWorkFilters : ScheduleWorkFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkFilters class.
		/// </summary>
		public ScheduleWorkFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ScheduleWorkFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ScheduleWorkFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ScheduleWorkFilters
	
	#region ScheduleWorkQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ScheduleWorkParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ScheduleWork"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ScheduleWorkQuery : ScheduleWorkParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkQuery class.
		/// </summary>
		public ScheduleWorkQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ScheduleWorkQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ScheduleWorkQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ScheduleWorkQuery
		
	#region SequenceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Sequence"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SequenceFilters : SequenceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SequenceFilters class.
		/// </summary>
		public SequenceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SequenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SequenceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SequenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SequenceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SequenceFilters
	
	#region SequenceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SequenceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Sequence"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SequenceQuery : SequenceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SequenceQuery class.
		/// </summary>
		public SequenceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SequenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SequenceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SequenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SequenceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SequenceQuery
		
	#region StockFilesTypeOfFileLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesTypeOfFileLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesTypeOfFileLogFilters : StockFilesTypeOfFileLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogFilters class.
		/// </summary>
		public StockFilesTypeOfFileLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesTypeOfFileLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesTypeOfFileLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesTypeOfFileLogFilters
	
	#region StockFilesTypeOfFileLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesTypeOfFileLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesTypeOfFileLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesTypeOfFileLogQuery : StockFilesTypeOfFileLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogQuery class.
		/// </summary>
		public StockFilesTypeOfFileLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesTypeOfFileLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesTypeOfFileLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesTypeOfFileLogQuery
		
	#region ScheduleWorkByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ScheduleWorkByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ScheduleWorkByCompaniesFilters : ScheduleWorkByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkByCompaniesFilters class.
		/// </summary>
		public ScheduleWorkByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ScheduleWorkByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ScheduleWorkByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ScheduleWorkByCompaniesFilters
	
	#region ScheduleWorkByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ScheduleWorkByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ScheduleWorkByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ScheduleWorkByCompaniesQuery : ScheduleWorkByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkByCompaniesQuery class.
		/// </summary>
		public ScheduleWorkByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ScheduleWorkByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ScheduleWorkByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ScheduleWorkByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ScheduleWorkByCompaniesQuery
		
	#region UsersLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersLogFilters : UsersLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersLogFilters class.
		/// </summary>
		public UsersLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersLogFilters
	
	#region UsersLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersLogQuery : UsersLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersLogQuery class.
		/// </summary>
		public UsersLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersLogQuery
		
	#region UsersGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersGroupsFilters : UsersGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersGroupsFilters class.
		/// </summary>
		public UsersGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersGroupsFilters
	
	#region UsersGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersGroupsQuery : UsersGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersGroupsQuery class.
		/// </summary>
		public UsersGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersGroupsQuery
		
	#region UsersGroupsByDepartmentsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersGroupsByDepartments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersGroupsByDepartmentsFilters : UsersGroupsByDepartmentsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersGroupsByDepartmentsFilters class.
		/// </summary>
		public UsersGroupsByDepartmentsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsByDepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersGroupsByDepartmentsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsByDepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersGroupsByDepartmentsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersGroupsByDepartmentsFilters
	
	#region UsersGroupsByDepartmentsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersGroupsByDepartmentsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersGroupsByDepartments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersGroupsByDepartmentsQuery : UsersGroupsByDepartmentsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersGroupsByDepartmentsQuery class.
		/// </summary>
		public UsersGroupsByDepartmentsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsByDepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersGroupsByDepartmentsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersGroupsByDepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersGroupsByDepartmentsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersGroupsByDepartmentsQuery
		
	#region CompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Companies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesFilters : CompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesFilters class.
		/// </summary>
		public CompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesFilters
	
	#region CompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Companies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesQuery : CompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesQuery class.
		/// </summary>
		public CompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesQuery
		
	#region UsersLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersLogByUuidFilters : UsersLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersLogByUuidFilters class.
		/// </summary>
		public UsersLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersLogByUuidFilters
	
	#region UsersLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersLogByUuidQuery : UsersLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersLogByUuidQuery class.
		/// </summary>
		public UsersLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersLogByUuidQuery
		
	#region UsersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Users"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersFilters : UsersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersFilters class.
		/// </summary>
		public UsersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersFilters
	
	#region UsersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Users"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersQuery : UsersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersQuery class.
		/// </summary>
		public UsersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersQuery
		
	#region UsersByUsersGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersByUsersGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByUsersGroupsFilters : UsersByUsersGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByUsersGroupsFilters class.
		/// </summary>
		public UsersByUsersGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByUsersGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByUsersGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByUsersGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByUsersGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByUsersGroupsFilters
	
	#region UsersByUsersGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersByUsersGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersByUsersGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByUsersGroupsQuery : UsersByUsersGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByUsersGroupsQuery class.
		/// </summary>
		public UsersByUsersGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByUsersGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByUsersGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByUsersGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByUsersGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByUsersGroupsQuery
		
	#region StockFilesTypeOfFileLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockFilesTypeOfFileLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesTypeOfFileLogByUuidFilters : StockFilesTypeOfFileLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogByUuidFilters class.
		/// </summary>
		public StockFilesTypeOfFileLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesTypeOfFileLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesTypeOfFileLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesTypeOfFileLogByUuidFilters
	
	#region StockFilesTypeOfFileLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockFilesTypeOfFileLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockFilesTypeOfFileLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockFilesTypeOfFileLogByUuidQuery : StockFilesTypeOfFileLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogByUuidQuery class.
		/// </summary>
		public StockFilesTypeOfFileLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockFilesTypeOfFileLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockFilesTypeOfFileLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockFilesTypeOfFileLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockFilesTypeOfFileLogByUuidQuery
		
	#region VpcControlFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VpcControl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcControlFilters : VpcControlFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcControlFilters class.
		/// </summary>
		public VpcControlFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcControlFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcControlFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcControlFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcControlFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcControlFilters
	
	#region VpcControlQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VpcControlParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VpcControl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcControlQuery : VpcControlParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcControlQuery class.
		/// </summary>
		public VpcControlQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcControlQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcControlQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcControlQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcControlQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcControlQuery
		
	#region UsersByGpsStocksFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersByGpsStocks"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByGpsStocksFilters : UsersByGpsStocksFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByGpsStocksFilters class.
		/// </summary>
		public UsersByGpsStocksFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsStocksFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByGpsStocksFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsStocksFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByGpsStocksFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByGpsStocksFilters
	
	#region UsersByGpsStocksQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersByGpsStocksParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersByGpsStocks"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByGpsStocksQuery : UsersByGpsStocksParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByGpsStocksQuery class.
		/// </summary>
		public UsersByGpsStocksQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsStocksQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByGpsStocksQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsStocksQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByGpsStocksQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByGpsStocksQuery
		
	#region VpcTrackDataFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VpcTrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcTrackDataFilters : VpcTrackDataFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcTrackDataFilters class.
		/// </summary>
		public VpcTrackDataFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcTrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcTrackDataFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcTrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcTrackDataFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcTrackDataFilters
	
	#region VpcTrackDataQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VpcTrackDataParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VpcTrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcTrackDataQuery : VpcTrackDataParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcTrackDataQuery class.
		/// </summary>
		public VpcTrackDataQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcTrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcTrackDataQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcTrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcTrackDataQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcTrackDataQuery
		
	#region VpcRecordTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VpcRecordType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcRecordTypeFilters : VpcRecordTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcRecordTypeFilters class.
		/// </summary>
		public VpcRecordTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcRecordTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcRecordTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcRecordTypeFilters
	
	#region VpcRecordTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VpcRecordTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VpcRecordType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcRecordTypeQuery : VpcRecordTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcRecordTypeQuery class.
		/// </summary>
		public VpcRecordTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcRecordTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcRecordTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcRecordTypeQuery
		
	#region VpcRecordLsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VpcRecordLs"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcRecordLsFilters : VpcRecordLsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcRecordLsFilters class.
		/// </summary>
		public VpcRecordLsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordLsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcRecordLsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordLsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcRecordLsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcRecordLsFilters
	
	#region VpcRecordLsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VpcRecordLsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VpcRecordLs"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcRecordLsQuery : VpcRecordLsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcRecordLsQuery class.
		/// </summary>
		public VpcRecordLsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordLsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcRecordLsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcRecordLsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcRecordLsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcRecordLsQuery
		
	#region VpcProcessFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VpcProcess"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcProcessFilters : VpcProcessFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcProcessFilters class.
		/// </summary>
		public VpcProcessFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcProcessFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcProcessFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcProcessFilters
	
	#region VpcProcessQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VpcProcessParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VpcProcess"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcProcessQuery : VpcProcessParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcProcessQuery class.
		/// </summary>
		public VpcProcessQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcProcessQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcProcessQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcProcessQuery
		
	#region VpcProcessDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VpcProcessDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcProcessDetailsFilters : VpcProcessDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcProcessDetailsFilters class.
		/// </summary>
		public VpcProcessDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcProcessDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcProcessDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcProcessDetailsFilters
	
	#region VpcProcessDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VpcProcessDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VpcProcessDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VpcProcessDetailsQuery : VpcProcessDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VpcProcessDetailsQuery class.
		/// </summary>
		public VpcProcessDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VpcProcessDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VpcProcessDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VpcProcessDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VpcProcessDetailsQuery
		
	#region WindowsServicesLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="WindowsServicesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WindowsServicesLogFilters : WindowsServicesLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WindowsServicesLogFilters class.
		/// </summary>
		public WindowsServicesLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the WindowsServicesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WindowsServicesLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WindowsServicesLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WindowsServicesLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WindowsServicesLogFilters
	
	#region WindowsServicesLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="WindowsServicesLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="WindowsServicesLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WindowsServicesLogQuery : WindowsServicesLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WindowsServicesLogQuery class.
		/// </summary>
		public WindowsServicesLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the WindowsServicesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WindowsServicesLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WindowsServicesLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WindowsServicesLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WindowsServicesLogQuery
		
	#region UsersByGpsGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByGpsGroupsFilters : UsersByGpsGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByGpsGroupsFilters class.
		/// </summary>
		public UsersByGpsGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByGpsGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByGpsGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByGpsGroupsFilters
	
	#region UsersByGpsGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersByGpsGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByGpsGroupsQuery : UsersByGpsGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByGpsGroupsQuery class.
		/// </summary>
		public UsersByGpsGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByGpsGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByGpsGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByGpsGroupsQuery
		
	#region UsersByEmailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UsersByEmail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByEmailFilters : UsersByEmailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByEmailFilters class.
		/// </summary>
		public UsersByEmailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByEmailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByEmailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByEmailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByEmailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByEmailFilters
	
	#region UsersByEmailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UsersByEmailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UsersByEmail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UsersByEmailQuery : UsersByEmailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UsersByEmailQuery class.
		/// </summary>
		public UsersByEmailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UsersByEmailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UsersByEmailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UsersByEmailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UsersByEmailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UsersByEmailQuery
		
	#region TrackDataFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataFilters : TrackDataFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataFilters class.
		/// </summary>
		public TrackDataFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataFilters
	
	#region TrackDataQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TrackDataParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TrackData"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataQuery : TrackDataParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataQuery class.
		/// </summary>
		public TrackDataQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataQuery
		
	#region StockSettingFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockSetting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockSettingFilters : StockSettingFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockSettingFilters class.
		/// </summary>
		public StockSettingFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockSettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockSettingFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockSettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockSettingFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockSettingFilters
	
	#region StockSettingQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockSettingParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockSetting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockSettingQuery : StockSettingParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockSettingQuery class.
		/// </summary>
		public StockSettingQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockSettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockSettingQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockSettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockSettingQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockSettingQuery
		
	#region StockLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockLogFilters : StockLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockLogFilters class.
		/// </summary>
		public StockLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockLogFilters
	
	#region StockLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockLogQuery : StockLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockLogQuery class.
		/// </summary>
		public StockLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockLogQuery
		
	#region StockLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockLogByUuidFilters : StockLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockLogByUuidFilters class.
		/// </summary>
		public StockLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockLogByUuidFilters
	
	#region StockLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockLogByUuidQuery : StockLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockLogByUuidQuery class.
		/// </summary>
		public StockLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockLogByUuidQuery
		
	#region TrackDataByClientsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TrackDataByClients"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataByClientsFilters : TrackDataByClientsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataByClientsFilters class.
		/// </summary>
		public TrackDataByClientsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataByClientsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataByClientsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataByClientsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataByClientsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataByClientsFilters
	
	#region TrackDataByClientsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TrackDataByClientsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TrackDataByClients"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataByClientsQuery : TrackDataByClientsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataByClientsQuery class.
		/// </summary>
		public TrackDataByClientsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataByClientsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataByClientsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataByClientsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataByClientsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataByClientsQuery
		
	#region StockSettingValuesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StockSettingValues"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockSettingValuesFilters : StockSettingValuesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockSettingValuesFilters class.
		/// </summary>
		public StockSettingValuesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockSettingValuesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockSettingValuesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockSettingValuesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockSettingValuesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockSettingValuesFilters
	
	#region StockSettingValuesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StockSettingValuesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StockSettingValues"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StockSettingValuesQuery : StockSettingValuesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StockSettingValuesQuery class.
		/// </summary>
		public StockSettingValuesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StockSettingValuesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StockSettingValuesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StockSettingValuesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StockSettingValuesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StockSettingValuesQuery
		
	#region TrackDataLastLocationFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TrackDataLastLocation"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastLocationFilters : TrackDataLastLocationFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationFilters class.
		/// </summary>
		public TrackDataLastLocationFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastLocationFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastLocationFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastLocationFilters
	
	#region TrackDataLastLocationQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TrackDataLastLocationParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TrackDataLastLocation"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastLocationQuery : TrackDataLastLocationParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationQuery class.
		/// </summary>
		public TrackDataLastLocationQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastLocationQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastLocationQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastLocationQuery
		
	#region UserRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UserRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserRolesFilters : UserRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserRolesFilters class.
		/// </summary>
		public UserRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserRolesFilters
	
	#region UserRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UserRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UserRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserRolesQuery : UserRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserRolesQuery class.
		/// </summary>
		public UserRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserRolesQuery
		
	#region UserRolesByUsersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UserRolesByUsers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserRolesByUsersFilters : UserRolesByUsersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserRolesByUsersFilters class.
		/// </summary>
		public UserRolesByUsersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserRolesByUsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserRolesByUsersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserRolesByUsersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserRolesByUsersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserRolesByUsersFilters
	
	#region UserRolesByUsersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UserRolesByUsersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UserRolesByUsers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserRolesByUsersQuery : UserRolesByUsersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserRolesByUsersQuery class.
		/// </summary>
		public UserRolesByUsersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserRolesByUsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserRolesByUsersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserRolesByUsersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserRolesByUsersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserRolesByUsersQuery
		
	#region TypeModulesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TypeModules"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TypeModulesFilters : TypeModulesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TypeModulesFilters class.
		/// </summary>
		public TypeModulesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TypeModulesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TypeModulesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TypeModulesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TypeModulesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TypeModulesFilters
	
	#region TypeModulesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TypeModulesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TypeModules"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TypeModulesQuery : TypeModulesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TypeModulesQuery class.
		/// </summary>
		public TypeModulesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TypeModulesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TypeModulesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TypeModulesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TypeModulesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TypeModulesQuery
		
	#region TrackDataLastVpcFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TrackDataLastVpc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastVpcFilters : TrackDataLastVpcFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastVpcFilters class.
		/// </summary>
		public TrackDataLastVpcFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastVpcFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastVpcFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastVpcFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastVpcFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastVpcFilters
	
	#region TrackDataLastVpcQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TrackDataLastVpcParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TrackDataLastVpc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastVpcQuery : TrackDataLastVpcParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastVpcQuery class.
		/// </summary>
		public TrackDataLastVpcQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastVpcQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastVpcQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastVpcQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastVpcQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastVpcQuery
		
	#region TrackDataLastLocationNotificationsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TrackDataLastLocationNotifications"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastLocationNotificationsFilters : TrackDataLastLocationNotificationsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationNotificationsFilters class.
		/// </summary>
		public TrackDataLastLocationNotificationsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationNotificationsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastLocationNotificationsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationNotificationsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastLocationNotificationsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastLocationNotificationsFilters
	
	#region TrackDataLastLocationNotificationsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TrackDataLastLocationNotificationsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TrackDataLastLocationNotifications"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TrackDataLastLocationNotificationsQuery : TrackDataLastLocationNotificationsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationNotificationsQuery class.
		/// </summary>
		public TrackDataLastLocationNotificationsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationNotificationsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TrackDataLastLocationNotificationsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TrackDataLastLocationNotificationsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TrackDataLastLocationNotificationsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TrackDataLastLocationNotificationsQuery
		
	#region NotificationsControlFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationsControl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsControlFilters : NotificationsControlFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsControlFilters class.
		/// </summary>
		public NotificationsControlFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsControlFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsControlFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsControlFilters
	
	#region NotificationsControlQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsControlParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationsControl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsControlQuery : NotificationsControlParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsControlQuery class.
		/// </summary>
		public NotificationsControlQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsControlQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsControlQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsControlQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsControlQuery
		
	#region NotificationsByGpsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationsByGps"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsByGpsFilters : NotificationsByGpsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsByGpsFilters class.
		/// </summary>
		public NotificationsByGpsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByGpsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsByGpsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByGpsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsByGpsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsByGpsFilters
	
	#region NotificationsByGpsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsByGpsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationsByGps"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsByGpsQuery : NotificationsByGpsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsByGpsQuery class.
		/// </summary>
		public NotificationsByGpsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByGpsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsByGpsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByGpsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsByGpsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsByGpsQuery
		
	#region ClientsLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsLogFilters : ClientsLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsLogFilters class.
		/// </summary>
		public ClientsLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsLogFilters
	
	#region ClientsLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsLogQuery : ClientsLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsLogQuery class.
		/// </summary>
		public ClientsLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsLogQuery
		
	#region ClientsGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsGroupsFilters : ClientsGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsFilters class.
		/// </summary>
		public ClientsGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsGroupsFilters
	
	#region ClientsGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsGroupsQuery : ClientsGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsQuery class.
		/// </summary>
		public ClientsGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsGroupsQuery
		
	#region ClientsControlFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsControl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsControlFilters : ClientsControlFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsControlFilters class.
		/// </summary>
		public ClientsControlFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsControlFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsControlFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsControlFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsControlFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsControlFilters
	
	#region ClientsControlQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsControlParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsControl"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsControlQuery : ClientsControlParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsControlQuery class.
		/// </summary>
		public ClientsControlQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsControlQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsControlQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsControlQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsControlQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsControlQuery
		
	#region ClientsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Clients"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsFilters : ClientsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsFilters class.
		/// </summary>
		public ClientsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsFilters
	
	#region ClientsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Clients"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsQuery : ClientsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsQuery class.
		/// </summary>
		public ClientsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsQuery
		
	#region ClientsLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsLogByUuidFilters : ClientsLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsLogByUuidFilters class.
		/// </summary>
		public ClientsLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsLogByUuidFilters
	
	#region ClientsLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsLogByUuidQuery : ClientsLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsLogByUuidQuery class.
		/// </summary>
		public ClientsLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsLogByUuidQuery
		
	#region ClientsGroupsByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsGroupsByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsGroupsByCompaniesFilters : ClientsGroupsByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsByCompaniesFilters class.
		/// </summary>
		public ClientsGroupsByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsGroupsByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsGroupsByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsGroupsByCompaniesFilters
	
	#region ClientsGroupsByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsGroupsByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsGroupsByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsGroupsByCompaniesQuery : ClientsGroupsByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsByCompaniesQuery class.
		/// </summary>
		public ClientsGroupsByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsGroupsByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsGroupsByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsGroupsByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsGroupsByCompaniesQuery
		
	#region ClientsToVisitFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsToVisit"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsToVisitFilters : ClientsToVisitFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsToVisitFilters class.
		/// </summary>
		public ClientsToVisitFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsToVisitFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsToVisitFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsToVisitFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsToVisitFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsToVisitFilters
	
	#region ClientsToVisitQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsToVisitParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsToVisit"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsToVisitQuery : ClientsToVisitParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsToVisitQuery class.
		/// </summary>
		public ClientsToVisitQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsToVisitQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsToVisitQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsToVisitQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsToVisitQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsToVisitQuery
		
	#region CompaniesByAdministratorsRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CompaniesByAdministratorsRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByAdministratorsRolesFilters : CompaniesByAdministratorsRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByAdministratorsRolesFilters class.
		/// </summary>
		public CompaniesByAdministratorsRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByAdministratorsRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByAdministratorsRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByAdministratorsRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByAdministratorsRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByAdministratorsRolesFilters
	
	#region CompaniesByAdministratorsRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesByAdministratorsRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CompaniesByAdministratorsRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByAdministratorsRolesQuery : CompaniesByAdministratorsRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByAdministratorsRolesQuery class.
		/// </summary>
		public CompaniesByAdministratorsRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByAdministratorsRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByAdministratorsRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByAdministratorsRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByAdministratorsRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByAdministratorsRolesQuery
		
	#region CompaniesByMenuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CompaniesByMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByMenuFilters : CompaniesByMenuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByMenuFilters class.
		/// </summary>
		public CompaniesByMenuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByMenuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByMenuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByMenuFilters
	
	#region CompaniesByMenuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesByMenuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CompaniesByMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByMenuQuery : CompaniesByMenuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByMenuQuery class.
		/// </summary>
		public CompaniesByMenuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByMenuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByMenuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByMenuQuery
		
	#region CompaniesByMastersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CompaniesByMasters"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByMastersFilters : CompaniesByMastersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByMastersFilters class.
		/// </summary>
		public CompaniesByMastersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMastersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByMastersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMastersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByMastersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByMastersFilters
	
	#region CompaniesByMastersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesByMastersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CompaniesByMasters"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByMastersQuery : CompaniesByMastersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByMastersQuery class.
		/// </summary>
		public CompaniesByMastersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMastersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByMastersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByMastersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByMastersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByMastersQuery
		
	#region CompaniesByGpsGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CompaniesByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByGpsGroupsFilters : CompaniesByGpsGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByGpsGroupsFilters class.
		/// </summary>
		public CompaniesByGpsGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByGpsGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByGpsGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByGpsGroupsFilters
	
	#region CompaniesByGpsGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesByGpsGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CompaniesByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByGpsGroupsQuery : CompaniesByGpsGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByGpsGroupsQuery class.
		/// </summary>
		public CompaniesByGpsGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByGpsGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByGpsGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByGpsGroupsQuery
		
	#region CompaniesByGeoFencesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CompaniesByGeoFences"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByGeoFencesFilters : CompaniesByGeoFencesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByGeoFencesFilters class.
		/// </summary>
		public CompaniesByGeoFencesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGeoFencesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByGeoFencesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGeoFencesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByGeoFencesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByGeoFencesFilters
	
	#region CompaniesByGeoFencesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesByGeoFencesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CompaniesByGeoFences"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByGeoFencesQuery : CompaniesByGeoFencesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByGeoFencesQuery class.
		/// </summary>
		public CompaniesByGeoFencesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGeoFencesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByGeoFencesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByGeoFencesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByGeoFencesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByGeoFencesQuery
		
	#region CompaniesByDepartmentsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CompaniesByDepartments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByDepartmentsFilters : CompaniesByDepartmentsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByDepartmentsFilters class.
		/// </summary>
		public CompaniesByDepartmentsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByDepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByDepartmentsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByDepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByDepartmentsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByDepartmentsFilters
	
	#region CompaniesByDepartmentsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesByDepartmentsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CompaniesByDepartments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesByDepartmentsQuery : CompaniesByDepartmentsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesByDepartmentsQuery class.
		/// </summary>
		public CompaniesByDepartmentsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByDepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesByDepartmentsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesByDepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesByDepartmentsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesByDepartmentsQuery
		
	#region ClientsByEmailLogByUuidFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsByEmailLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByEmailLogByUuidFilters : ClientsByEmailLogByUuidFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogByUuidFilters class.
		/// </summary>
		public ClientsByEmailLogByUuidFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByEmailLogByUuidFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogByUuidFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByEmailLogByUuidFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByEmailLogByUuidFilters
	
	#region ClientsByEmailLogByUuidQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsByEmailLogByUuidParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsByEmailLogByUuid"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByEmailLogByUuidQuery : ClientsByEmailLogByUuidParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogByUuidQuery class.
		/// </summary>
		public ClientsByEmailLogByUuidQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByEmailLogByUuidQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogByUuidQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByEmailLogByUuidQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByEmailLogByUuidQuery
		
	#region ClientsByEmailLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsByEmailLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByEmailLogFilters : ClientsByEmailLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogFilters class.
		/// </summary>
		public ClientsByEmailLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByEmailLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByEmailLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByEmailLogFilters
	
	#region ClientsByEmailLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsByEmailLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsByEmailLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByEmailLogQuery : ClientsByEmailLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogQuery class.
		/// </summary>
		public ClientsByEmailLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByEmailLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByEmailLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByEmailLogQuery
		
	#region ClientsByEmailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsByEmail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByEmailFilters : ClientsByEmailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailFilters class.
		/// </summary>
		public ClientsByEmailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByEmailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByEmailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByEmailFilters
	
	#region ClientsByEmailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsByEmailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsByEmail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByEmailQuery : ClientsByEmailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailQuery class.
		/// </summary>
		public ClientsByEmailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByEmailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByEmailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByEmailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByEmailQuery
		
	#region AdministratorsRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdministratorsRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsRolesFilters : AdministratorsRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesFilters class.
		/// </summary>
		public AdministratorsRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsRolesFilters
	
	#region AdministratorsRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdministratorsRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdministratorsRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsRolesQuery : AdministratorsRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesQuery class.
		/// </summary>
		public AdministratorsRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsRolesQuery
		
	#region AdministratorsRolesByAdministratorFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdministratorsRolesByAdministrator"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsRolesByAdministratorFilters : AdministratorsRolesByAdministratorFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesByAdministratorFilters class.
		/// </summary>
		public AdministratorsRolesByAdministratorFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesByAdministratorFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsRolesByAdministratorFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesByAdministratorFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsRolesByAdministratorFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsRolesByAdministratorFilters
	
	#region AdministratorsRolesByAdministratorQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdministratorsRolesByAdministratorParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdministratorsRolesByAdministrator"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsRolesByAdministratorQuery : AdministratorsRolesByAdministratorParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesByAdministratorQuery class.
		/// </summary>
		public AdministratorsRolesByAdministratorQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesByAdministratorQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsRolesByAdministratorQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsRolesByAdministratorQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsRolesByAdministratorQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsRolesByAdministratorQuery
		
	#region AdministratorsByEmailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdministratorsByEmail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsByEmailFilters : AdministratorsByEmailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsByEmailFilters class.
		/// </summary>
		public AdministratorsByEmailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByEmailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsByEmailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByEmailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsByEmailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsByEmailFilters
	
	#region AdministratorsByEmailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdministratorsByEmailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdministratorsByEmail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsByEmailQuery : AdministratorsByEmailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsByEmailQuery class.
		/// </summary>
		public AdministratorsByEmailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByEmailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsByEmailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByEmailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsByEmailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsByEmailQuery
		
	#region AdministratorsByDepartmentsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdministratorsByDepartments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsByDepartmentsFilters : AdministratorsByDepartmentsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsByDepartmentsFilters class.
		/// </summary>
		public AdministratorsByDepartmentsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByDepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsByDepartmentsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByDepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsByDepartmentsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsByDepartmentsFilters
	
	#region AdministratorsByDepartmentsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdministratorsByDepartmentsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdministratorsByDepartments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdministratorsByDepartmentsQuery : AdministratorsByDepartmentsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdministratorsByDepartmentsQuery class.
		/// </summary>
		public AdministratorsByDepartmentsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByDepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdministratorsByDepartmentsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdministratorsByDepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdministratorsByDepartmentsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdministratorsByDepartmentsQuery
		
	#region BusRoutesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BusRoutes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRoutesFilters : BusRoutesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRoutesFilters class.
		/// </summary>
		public BusRoutesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRoutesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRoutesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRoutesFilters
	
	#region BusRoutesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BusRoutesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BusRoutes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRoutesQuery : BusRoutesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRoutesQuery class.
		/// </summary>
		public BusRoutesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRoutesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRoutesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRoutesQuery
		
	#region BusRoutesDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BusRoutesDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRoutesDetailsFilters : BusRoutesDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRoutesDetailsFilters class.
		/// </summary>
		public BusRoutesDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRoutesDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRoutesDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRoutesDetailsFilters
	
	#region BusRoutesDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BusRoutesDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BusRoutesDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRoutesDetailsQuery : BusRoutesDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRoutesDetailsQuery class.
		/// </summary>
		public BusRoutesDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRoutesDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRoutesDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRoutesDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRoutesDetailsQuery
		
	#region ClientsByClientsGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ClientsByClientsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByClientsGroupsFilters : ClientsByClientsGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByClientsGroupsFilters class.
		/// </summary>
		public ClientsByClientsGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByClientsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByClientsGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByClientsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByClientsGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByClientsGroupsFilters
	
	#region ClientsByClientsGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ClientsByClientsGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ClientsByClientsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ClientsByClientsGroupsQuery : ClientsByClientsGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ClientsByClientsGroupsQuery class.
		/// </summary>
		public ClientsByClientsGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ClientsByClientsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ClientsByClientsGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ClientsByClientsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ClientsByClientsGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ClientsByClientsGroupsQuery
		
	#region CatalogStatisticsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CatalogStatistics"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CatalogStatisticsFilters : CatalogStatisticsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CatalogStatisticsFilters class.
		/// </summary>
		public CatalogStatisticsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CatalogStatisticsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CatalogStatisticsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CatalogStatisticsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CatalogStatisticsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CatalogStatisticsFilters
	
	#region CatalogStatisticsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CatalogStatisticsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CatalogStatistics"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CatalogStatisticsQuery : CatalogStatisticsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CatalogStatisticsQuery class.
		/// </summary>
		public CatalogStatisticsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CatalogStatisticsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CatalogStatisticsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CatalogStatisticsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CatalogStatisticsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CatalogStatisticsQuery
		
	#region BusStopFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BusStop"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusStopFilters : BusStopFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusStopFilters class.
		/// </summary>
		public BusStopFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusStopFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusStopFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusStopFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusStopFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusStopFilters
	
	#region BusStopQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BusStopParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BusStop"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusStopQuery : BusStopParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusStopQuery class.
		/// </summary>
		public BusStopQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusStopQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusStopQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusStopQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusStopQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusStopQuery
		
	#region BusRouteByGpsGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BusRouteByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRouteByGpsGroupsFilters : BusRouteByGpsGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRouteByGpsGroupsFilters class.
		/// </summary>
		public BusRouteByGpsGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRouteByGpsGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRouteByGpsGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRouteByGpsGroupsFilters
	
	#region BusRouteByGpsGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BusRouteByGpsGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BusRouteByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRouteByGpsGroupsQuery : BusRouteByGpsGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRouteByGpsGroupsQuery class.
		/// </summary>
		public BusRouteByGpsGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRouteByGpsGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRouteByGpsGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRouteByGpsGroupsQuery
		
	#region BusStopByBusRoutesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BusStopByBusRoutes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusStopByBusRoutesFilters : BusStopByBusRoutesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusStopByBusRoutesFilters class.
		/// </summary>
		public BusStopByBusRoutesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusStopByBusRoutesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusStopByBusRoutesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusStopByBusRoutesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusStopByBusRoutesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusStopByBusRoutesFilters
	
	#region BusStopByBusRoutesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BusStopByBusRoutesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BusStopByBusRoutes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusStopByBusRoutesQuery : BusStopByBusRoutesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusStopByBusRoutesQuery class.
		/// </summary>
		public BusStopByBusRoutesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusStopByBusRoutesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusStopByBusRoutesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusStopByBusRoutesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusStopByBusRoutesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusStopByBusRoutesQuery
		
	#region CompaniesBySettingFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CompaniesBySetting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesBySettingFilters : CompaniesBySettingFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesBySettingFilters class.
		/// </summary>
		public CompaniesBySettingFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesBySettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesBySettingFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesBySettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesBySettingFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesBySettingFilters
	
	#region CompaniesBySettingQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CompaniesBySettingParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CompaniesBySetting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CompaniesBySettingQuery : CompaniesBySettingParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CompaniesBySettingQuery class.
		/// </summary>
		public CompaniesBySettingQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CompaniesBySettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CompaniesBySettingQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CompaniesBySettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CompaniesBySettingQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CompaniesBySettingQuery
		
	#region BusRouteByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BusRouteByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRouteByCompaniesFilters : BusRouteByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRouteByCompaniesFilters class.
		/// </summary>
		public BusRouteByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRouteByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRouteByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRouteByCompaniesFilters
	
	#region BusRouteByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BusRouteByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BusRouteByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BusRouteByCompaniesQuery : BusRouteByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BusRouteByCompaniesQuery class.
		/// </summary>
		public BusRouteByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BusRouteByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BusRouteByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BusRouteByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BusRouteByCompaniesQuery
		
	#region MastersRolesByMasterFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MastersRolesByMaster"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MastersRolesByMasterFilters : MastersRolesByMasterFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MastersRolesByMasterFilters class.
		/// </summary>
		public MastersRolesByMasterFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MastersRolesByMasterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MastersRolesByMasterFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MastersRolesByMasterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MastersRolesByMasterFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MastersRolesByMasterFilters
	
	#region MastersRolesByMasterQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MastersRolesByMasterParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MastersRolesByMaster"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MastersRolesByMasterQuery : MastersRolesByMasterParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MastersRolesByMasterQuery class.
		/// </summary>
		public MastersRolesByMasterQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MastersRolesByMasterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MastersRolesByMasterQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MastersRolesByMasterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MastersRolesByMasterQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MastersRolesByMasterQuery
		
	#region MenuTypesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MenuTypes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuTypesFilters : MenuTypesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuTypesFilters class.
		/// </summary>
		public MenuTypesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuTypesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuTypesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuTypesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuTypesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuTypesFilters
	
	#region MenuTypesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MenuTypesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MenuTypes"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuTypesQuery : MenuTypesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuTypesQuery class.
		/// </summary>
		public MenuTypesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuTypesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuTypesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuTypesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuTypesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuTypesQuery
		
	#region MastersFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Masters"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MastersFilters : MastersFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MastersFilters class.
		/// </summary>
		public MastersFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MastersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MastersFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MastersFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MastersFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MastersFilters
	
	#region MastersQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MastersParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Masters"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MastersQuery : MastersParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MastersQuery class.
		/// </summary>
		public MastersQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MastersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MastersQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MastersQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MastersQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MastersQuery
		
	#region DayNamesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DayNames"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DayNamesFilters : DayNamesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DayNamesFilters class.
		/// </summary>
		public DayNamesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DayNamesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DayNamesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DayNamesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DayNamesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DayNamesFilters
	
	#region DayNamesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DayNamesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DayNames"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DayNamesQuery : DayNamesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DayNamesQuery class.
		/// </summary>
		public DayNamesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DayNamesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DayNamesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DayNamesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DayNamesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DayNamesQuery
		
	#region MasterRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MasterRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MasterRolesFilters : MasterRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MasterRolesFilters class.
		/// </summary>
		public MasterRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MasterRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MasterRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MasterRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MasterRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MasterRolesFilters
	
	#region MasterRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MasterRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MasterRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MasterRolesQuery : MasterRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MasterRolesQuery class.
		/// </summary>
		public MasterRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MasterRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MasterRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MasterRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MasterRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MasterRolesQuery
		
	#region MenuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Menu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuFilters : MenuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuFilters class.
		/// </summary>
		public MenuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuFilters
	
	#region MenuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MenuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Menu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuQuery : MenuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuQuery class.
		/// </summary>
		public MenuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuQuery
		
	#region LogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Log"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LogFilters : LogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LogFilters class.
		/// </summary>
		public LogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the LogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LogFilters
	
	#region LogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="LogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Log"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LogQuery : LogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LogQuery class.
		/// </summary>
		public LogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the LogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LogQuery
		
	#region GpsTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GpsType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsTypeFilters : GpsTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsTypeFilters class.
		/// </summary>
		public GpsTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsTypeFilters
	
	#region GpsTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GpsTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GpsType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsTypeQuery : GpsTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsTypeQuery class.
		/// </summary>
		public GpsTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsTypeQuery
		
	#region MenuByAdministratorRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MenuByAdministratorRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuByAdministratorRolesFilters : MenuByAdministratorRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuByAdministratorRolesFilters class.
		/// </summary>
		public MenuByAdministratorRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuByAdministratorRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuByAdministratorRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuByAdministratorRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuByAdministratorRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuByAdministratorRolesFilters
	
	#region MenuByAdministratorRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MenuByAdministratorRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MenuByAdministratorRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuByAdministratorRolesQuery : MenuByAdministratorRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuByAdministratorRolesQuery class.
		/// </summary>
		public MenuByAdministratorRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuByAdministratorRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuByAdministratorRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuByAdministratorRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuByAdministratorRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuByAdministratorRolesQuery
		
	#region NotificationsByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationsByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsByCompaniesFilters : NotificationsByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsByCompaniesFilters class.
		/// </summary>
		public NotificationsByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsByCompaniesFilters
	
	#region NotificationsByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationsByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationsByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationsByCompaniesQuery : NotificationsByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationsByCompaniesQuery class.
		/// </summary>
		public NotificationsByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationsByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationsByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationsByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationsByCompaniesQuery
		
	#region MessageQueueLogFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MessageQueueLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MessageQueueLogFilters : MessageQueueLogFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MessageQueueLogFilters class.
		/// </summary>
		public MessageQueueLogFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MessageQueueLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MessageQueueLogFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MessageQueueLogFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MessageQueueLogFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MessageQueueLogFilters
	
	#region MessageQueueLogQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MessageQueueLogParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MessageQueueLog"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MessageQueueLogQuery : MessageQueueLogParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MessageQueueLogQuery class.
		/// </summary>
		public MessageQueueLogQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MessageQueueLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MessageQueueLogQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MessageQueueLogQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MessageQueueLogQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MessageQueueLogQuery
		
	#region MenuByUserRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MenuByUserRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuByUserRolesFilters : MenuByUserRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuByUserRolesFilters class.
		/// </summary>
		public MenuByUserRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuByUserRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuByUserRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuByUserRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuByUserRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuByUserRolesFilters
	
	#region MenuByUserRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MenuByUserRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MenuByUserRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuByUserRolesQuery : MenuByUserRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuByUserRolesQuery class.
		/// </summary>
		public MenuByUserRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuByUserRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuByUserRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuByUserRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuByUserRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuByUserRolesQuery
		
	#region MenuByMasterRolesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MenuByMasterRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuByMasterRolesFilters : MenuByMasterRolesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuByMasterRolesFilters class.
		/// </summary>
		public MenuByMasterRolesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuByMasterRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuByMasterRolesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuByMasterRolesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuByMasterRolesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuByMasterRolesFilters
	
	#region MenuByMasterRolesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MenuByMasterRolesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MenuByMasterRoles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuByMasterRolesQuery : MenuByMasterRolesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuByMasterRolesQuery class.
		/// </summary>
		public MenuByMasterRolesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuByMasterRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuByMasterRolesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuByMasterRolesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuByMasterRolesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuByMasterRolesQuery
		
	#region GpsModelsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GpsModels"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsModelsFilters : GpsModelsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsModelsFilters class.
		/// </summary>
		public GpsModelsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsModelsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsModelsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsModelsFilters
	
	#region GpsModelsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GpsModelsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GpsModels"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsModelsQuery : GpsModelsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsModelsQuery class.
		/// </summary>
		public GpsModelsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsModelsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsModelsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsModelsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsModelsQuery
		
	#region GpsStockFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GpsStock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsStockFilters : GpsStockFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsStockFilters class.
		/// </summary>
		public GpsStockFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsStockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsStockFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsStockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsStockFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsStockFilters
	
	#region GpsStockQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GpsStockParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GpsStock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsStockQuery : GpsStockParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsStockQuery class.
		/// </summary>
		public GpsStockQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsStockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsStockQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsStockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsStockQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsStockQuery
		
	#region GpsStockByGpsGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GpsStockByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsStockByGpsGroupsFilters : GpsStockByGpsGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsStockByGpsGroupsFilters class.
		/// </summary>
		public GpsStockByGpsGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsStockByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsStockByGpsGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsStockByGpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsStockByGpsGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsStockByGpsGroupsFilters
	
	#region GpsStockByGpsGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GpsStockByGpsGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GpsStockByGpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsStockByGpsGroupsQuery : GpsStockByGpsGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsStockByGpsGroupsQuery class.
		/// </summary>
		public GpsStockByGpsGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsStockByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsStockByGpsGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsStockByGpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsStockByGpsGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsStockByGpsGroupsQuery
		
	#region EmailToSendStocksFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="EmailToSendStocks"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStocksFilters : EmailToSendStocksFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStocksFilters class.
		/// </summary>
		public EmailToSendStocksFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStocksFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStocksFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStocksFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStocksFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStocksFilters
	
	#region EmailToSendStocksQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="EmailToSendStocksParameterBuilder"/> class
	/// that is used exclusively with a <see cref="EmailToSendStocks"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStocksQuery : EmailToSendStocksParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStocksQuery class.
		/// </summary>
		public EmailToSendStocksQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStocksQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStocksQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStocksQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStocksQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStocksQuery
		
	#region EmailToSendStockByClientsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="EmailToSendStockByClients"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStockByClientsFilters : EmailToSendStockByClientsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByClientsFilters class.
		/// </summary>
		public EmailToSendStockByClientsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByClientsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStockByClientsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByClientsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStockByClientsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStockByClientsFilters
	
	#region EmailToSendStockByClientsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="EmailToSendStockByClientsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="EmailToSendStockByClients"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStockByClientsQuery : EmailToSendStockByClientsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByClientsQuery class.
		/// </summary>
		public EmailToSendStockByClientsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByClientsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStockByClientsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByClientsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStockByClientsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStockByClientsQuery
		
	#region DriversFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Drivers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DriversFilters : DriversFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DriversFilters class.
		/// </summary>
		public DriversFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DriversFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DriversFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DriversFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DriversFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DriversFilters
	
	#region DriversQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DriversParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Drivers"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DriversQuery : DriversParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DriversQuery class.
		/// </summary>
		public DriversQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DriversQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DriversQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DriversQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DriversQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DriversQuery
		
	#region DepartmentsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Departments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DepartmentsFilters : DepartmentsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DepartmentsFilters class.
		/// </summary>
		public DepartmentsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DepartmentsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DepartmentsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DepartmentsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DepartmentsFilters
	
	#region DepartmentsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DepartmentsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Departments"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DepartmentsQuery : DepartmentsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DepartmentsQuery class.
		/// </summary>
		public DepartmentsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DepartmentsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DepartmentsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DepartmentsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DepartmentsQuery
		
	#region DriversByCompaniesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DriversByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DriversByCompaniesFilters : DriversByCompaniesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DriversByCompaniesFilters class.
		/// </summary>
		public DriversByCompaniesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DriversByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DriversByCompaniesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DriversByCompaniesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DriversByCompaniesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DriversByCompaniesFilters
	
	#region DriversByCompaniesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DriversByCompaniesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DriversByCompanies"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DriversByCompaniesQuery : DriversByCompaniesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DriversByCompaniesQuery class.
		/// </summary>
		public DriversByCompaniesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DriversByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DriversByCompaniesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DriversByCompaniesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DriversByCompaniesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DriversByCompaniesQuery
		
	#region EmailToSendStockByStockFilesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="EmailToSendStockByStockFiles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStockByStockFilesFilters : EmailToSendStockByStockFilesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStockFilesFilters class.
		/// </summary>
		public EmailToSendStockByStockFilesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStockFilesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStockByStockFilesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStockFilesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStockByStockFilesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStockByStockFilesFilters
	
	#region EmailToSendStockByStockFilesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="EmailToSendStockByStockFilesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="EmailToSendStockByStockFiles"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStockByStockFilesQuery : EmailToSendStockByStockFilesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStockFilesQuery class.
		/// </summary>
		public EmailToSendStockByStockFilesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStockFilesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStockByStockFilesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStockFilesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStockByStockFilesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStockByStockFilesQuery
		
	#region NotificationByGeoFencesByGpsStockFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NotificationByGeoFencesByGpsStock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationByGeoFencesByGpsStockFilters : NotificationByGeoFencesByGpsStockFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationByGeoFencesByGpsStockFilters class.
		/// </summary>
		public NotificationByGeoFencesByGpsStockFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationByGeoFencesByGpsStockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationByGeoFencesByGpsStockFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationByGeoFencesByGpsStockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationByGeoFencesByGpsStockFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationByGeoFencesByGpsStockFilters
	
	#region NotificationByGeoFencesByGpsStockQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NotificationByGeoFencesByGpsStockParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NotificationByGeoFencesByGpsStock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NotificationByGeoFencesByGpsStockQuery : NotificationByGeoFencesByGpsStockParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NotificationByGeoFencesByGpsStockQuery class.
		/// </summary>
		public NotificationByGeoFencesByGpsStockQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NotificationByGeoFencesByGpsStockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NotificationByGeoFencesByGpsStockQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NotificationByGeoFencesByGpsStockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NotificationByGeoFencesByGpsStockQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NotificationByGeoFencesByGpsStockQuery
		
	#region GeoFencesFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GeoFences"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFencesFilters : GeoFencesFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFencesFilters class.
		/// </summary>
		public GeoFencesFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFencesFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFencesFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFencesFilters
	
	#region GeoFencesQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GeoFencesParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GeoFences"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFencesQuery : GeoFencesParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFencesQuery class.
		/// </summary>
		public GeoFencesQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFencesQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFencesQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFencesQuery
		
	#region EmailToSendStockByStocksFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="EmailToSendStockByStocks"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStockByStocksFilters : EmailToSendStockByStocksFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStocksFilters class.
		/// </summary>
		public EmailToSendStockByStocksFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStocksFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStockByStocksFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStocksFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStockByStocksFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStockByStocksFilters
	
	#region EmailToSendStockByStocksQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="EmailToSendStockByStocksParameterBuilder"/> class
	/// that is used exclusively with a <see cref="EmailToSendStockByStocks"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class EmailToSendStockByStocksQuery : EmailToSendStockByStocksParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStocksQuery class.
		/// </summary>
		public EmailToSendStockByStocksQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStocksQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public EmailToSendStockByStocksQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the EmailToSendStockByStocksQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public EmailToSendStockByStocksQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion EmailToSendStockByStocksQuery
		
	#region GpsCommandsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GpsCommands"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsCommandsFilters : GpsCommandsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsCommandsFilters class.
		/// </summary>
		public GpsCommandsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsCommandsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsCommandsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsCommandsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsCommandsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsCommandsFilters
	
	#region GpsCommandsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GpsCommandsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GpsCommands"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsCommandsQuery : GpsCommandsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsCommandsQuery class.
		/// </summary>
		public GpsCommandsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsCommandsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsCommandsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsCommandsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsCommandsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsCommandsQuery
		
	#region GpsGroupsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsGroupsFilters : GpsGroupsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsGroupsFilters class.
		/// </summary>
		public GpsGroupsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsGroupsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsGroupsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsGroupsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsGroupsFilters
	
	#region GpsGroupsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GpsGroupsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GpsGroups"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GpsGroupsQuery : GpsGroupsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GpsGroupsQuery class.
		/// </summary>
		public GpsGroupsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GpsGroupsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GpsGroupsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GpsGroupsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GpsGroupsQuery
		
	#region GeoFencesByGpsStockFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GeoFencesByGpsStock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFencesByGpsStockFilters : GeoFencesByGpsStockFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFencesByGpsStockFilters class.
		/// </summary>
		public GeoFencesByGpsStockFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesByGpsStockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFencesByGpsStockFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesByGpsStockFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFencesByGpsStockFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFencesByGpsStockFilters
	
	#region GeoFencesByGpsStockQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GeoFencesByGpsStockParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GeoFencesByGpsStock"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFencesByGpsStockQuery : GeoFencesByGpsStockParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFencesByGpsStockQuery class.
		/// </summary>
		public GeoFencesByGpsStockQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesByGpsStockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFencesByGpsStockQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFencesByGpsStockQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFencesByGpsStockQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFencesByGpsStockQuery
		
	#region GeoFenceDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GeoFenceDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceDetailsFilters : GeoFenceDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsFilters class.
		/// </summary>
		public GeoFenceDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceDetailsFilters
	
	#region GeoFenceDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GeoFenceDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GeoFenceDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GeoFenceDetailsQuery : GeoFenceDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsQuery class.
		/// </summary>
		public GeoFenceDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GeoFenceDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GeoFenceDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GeoFenceDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GeoFenceDetailsQuery
		
	#region WorkTimeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="WorkTime"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WorkTimeFilters : WorkTimeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WorkTimeFilters class.
		/// </summary>
		public WorkTimeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the WorkTimeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WorkTimeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WorkTimeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WorkTimeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WorkTimeFilters
	
	#region WorkTimeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="WorkTimeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="WorkTime"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class WorkTimeQuery : WorkTimeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the WorkTimeQuery class.
		/// </summary>
		public WorkTimeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the WorkTimeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public WorkTimeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the WorkTimeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public WorkTimeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion WorkTimeQuery
	#endregion

	
}
